#include "level.hpp"
#include "message.hpp"
#include "formatter.hpp"
#include "util.hpp"
#include "sink.hpp"
#include <unistd.h>
#include"buffer.hpp"
#include<cstring>
#include"logger.hpp"
#include"zxlog.hpp"
int main()
{
    //全局接口测试
    zxlog::BuildLogger::ptr builder = std::make_shared<zxlog::LocalBuildLogger>();
    builder->BuildLoggerName("AsyncLogger");
    zxlog::Logger::ptr logger = builder->Builder();
    LOGD("%s count = %d ","创建套接字失败...");
    DEBUG(logger,"%s count = %d ","创建套接字失败...");
    


    //日志器管理者和全局建造者测试
    
   // zxlog::LoggerManager::getInstance().rootLogger()->debug(__FILE__,__LINE__,"%s","创建套接字失败...");
   // zxlog::BuildLogger::ptr builder = std::make_shared<zxlog::GlobalBuildLogger>();
   // builder->BuildLoggerType(zxlog::Logger::LoggerType::ASYNC_LOGGER);
   // builder->BuildLooperType(zxlog::AsyncLooper::AsyncType::ASYNC_SAFE);
   // builder->BuildSinks<zxlog::FileSink>("tmp.log");
   // builder->BuildSinks<zxlog::RollSink>("a/tmp",1024*1024);
   // builder->BuildLoggerName("AsyncLogger");
   // zxlog::Logger::ptr logger = builder->Builder();
   // zxlog::LoggerManager::getInstance().addLogger("AsyncLogger",logger);
   // if(zxlog::LoggerManager::getInstance().hasLogger("AsyncLogger"))
   // {
   //     zxlog::LoggerManager::getInstance().getLogger("AsyncLogger")->debug(__FILE__,__LINE__,"123");
   // }
    

    //异步日志器测试
//    zxlog::BuildLogger::ptr builder = std::make_shared<zxlog::LocalBuildLogger>();
//    builder->BuildLoggerType(zxlog::Logger::LoggerType::ASYNC_LOGGER);
//    builder->BuildLooperType(zxlog::AsyncLooper::AsyncType::ASYNC_SAFE);
//    builder->BuildSinks<zxlog::FileSink>("tmp.log");
//    builder->BuildSinks<zxlog::RollSink>("a/tmp",1024*1024);
//    builder->BuildLoggerName("AsyncLogger");
//    zxlog::Logger::ptr logger = builder->Builder();
//    int count = 1000000;
//    while(count--){
//    logger->debug(__FILE__,__LINE__,"%s count = %d ","创建套接字失败...",count);
//    }
//
//
   //日志器建造者类测试
    //zxlog::BuildLogger::ptr build_logger = std::make_shared<zxlog::LocalBuildLogger>();
    //build_logger->BuildLoggerName("SyncLogger");
    //zxlog::Logger::ptr logger = build_logger->Builder();
    //logger->debug(__FILE__,__LINE__,"%s","日志器创建失败...");


    //同步日志器的测试
//    std::string logger_name("Sync");
//    zxlog::LogLevel::Value level = zxlog::LogLevel::Value::DEBUG;
//    zxlog::Formatter::ptr formatter = std::make_shared<zxlog::Formatter>();
//    std::vector<zxlog::LogSink::ptr> sinks;
//    zxlog::LogSink::ptr stdout_sink = std::make_shared<zxlog::StdoutSink>();
//    sinks.push_back(stdout_sink);
//    zxlog::Logger::ptr sync_logger = std::make_shared<zxlog::SyncLogger>(logger_name,level,formatter,sinks);
//    std::string str = "hello world";
//    sync_logger->Log(str.c_str(),str.size());
    return 0;
}


//void test_pointer_movement() {
//    std::cout << "\n=== 读写指针移动测试 ===" << std::endl;
//    
//    zxlog::Buffer buf;
//    
//    // 分多次写入
//    buf.push("Hello", 5);
//    buf.push(" World", 6);
//    
//    assert(buf.readAbleSize() == 11);
//    
//    // 验证完整数据
//    const char* data = buf.begin();
//    std::string result(data, 11);
//    assert(result == "Hello World");
//    
//    // 分多次读取
//    buf.moveReader(5); // 移动读指针5字节
//    assert(buf.readAbleSize() == 6);
//    
//    const char* remaining = buf.begin();
//    std::string remaining_str(remaining, 6);
//    assert(remaining_str == " World");
//    
//    buf.pop(6); // 读取剩余数据
//    assert(buf.empty());
//    
//    std::cout << "指针移动测试通过!" << std::endl;
//}
//void test_buffer_expansion() {
//    std::cout << "\n=== 缓冲区扩容测试 ===" << std::endl;
//    
//    zxlog::Buffer buf;
//    size_t initial_size = buf.writerAbleSize();
//    
//    // 写入超过初始容量的数据
//    std::vector<char> large_data(BUFFER_DEFAULT_SIZE + 100);
//    for (size_t i = 0; i < large_data.size(); ++i) {
//        large_data[i] = 'A' + (i % 26);
//    }
//    
//    buf.push(large_data.data(), large_data.size());
//    
//    // 验证数据完整性
//    assert(buf.readAbleSize() == large_data.size());
//    assert(memcmp(buf.begin(), large_data.data(), large_data.size()) == 0);
//    
//    std::cout << "初始容量: " << initial_size << std::endl;
//    std::cout << "扩容测试通过!" << std::endl;
//}
//void test_boundary_conditions() {
//    std::cout << "\n=== 边界条件测试 ===" << std::endl;
//    
//    zxlog::Buffer buf;
//    
//    // 测试空缓冲区操作
//    assert(buf.empty());
//    buf.pop(0); // 应该允许弹出0字节
//    assert(buf.empty());
//    
//    // 测试写入0字节
//    buf.push("", 0);
//    assert(buf.empty());
//    
//    // 测试单字节操作
//    buf.push("A", 1);
//    assert(buf.readAbleSize() == 1);
//    assert(*buf.begin() == 'A');
//    
//    buf.pop(1);
//    assert(buf.empty());
//    
//    std::cout << "边界条件测试通过!" << std::endl;
//}
//void test_basic_functionality() {
//    std::cout << "=== 基础功能测试 ===" << std::endl;
//    
//    zxlog::Buffer buf;
//    
//    // 测试初始状态
//    assert(buf.empty());
//    assert(buf.readAbleSize() == 0);
//    assert(buf.writerAbleSize() == BUFFER_DEFAULT_SIZE);
//    
//    // 测试写入数据
//    const char* test_data = "Hello, Buffer!";
//    size_t len = strlen(test_data);
//    buf.push(test_data, len);
//    
//    assert(!buf.empty());
//    assert(buf.readAbleSize() == len);
//    assert(buf.writerAbleSize() == BUFFER_DEFAULT_SIZE - len);
//    
//    // 测试读取数据
//    const char* read_ptr = buf.begin();
//    assert(memcmp(read_ptr, test_data, len) == 0);
//    
//    buf.pop(len);
//    assert(buf.empty());
//    
//    std::cout << "基础功能测试通过!" << std::endl;
//}
//void test_buffer_swap() {
//    std::cout << "\n=== 缓冲区交换测试 ===" << std::endl;
//    
//    zxlog::Buffer buf1, buf2;
//    
//    buf1.push("Buffer1", 7);
//    buf2.push("Buffer2", 7);
//    
//    // 记录交换前的状态
//    size_t buf1_size_before = buf1.readAbleSize();
//    size_t buf2_size_before = buf2.readAbleSize();
//    
//    // 执行交换
//    buf1.swap(buf2);
//    
//    // 验证交换结果
//    assert(buf1.readAbleSize() == buf2_size_before);
//    assert(buf2.readAbleSize() == buf1_size_before);
//    
//    assert(memcmp(buf1.begin(), "Buffer2", 7) == 0);
//    assert(memcmp(buf2.begin(), "Buffer1", 7) == 0);
//    
//    std::cout << "缓冲区交换测试通过!" << std::endl;
//}
//void test_reset_function() {
//    std::cout << "\n=== 重置功能测试 ===" << std::endl;
//
//    zxlog::Buffer buf;
//
//    // 写入数据
//    buf.push("Test Data", 9);
//    assert(!buf.empty());
//
//    // 重置缓冲区
//    buf.reset();
//    assert(buf.empty());
//    assert(buf.readAbleSize() == 0);
//
//    // 重置后可以重新使用
//    buf.push("New Data", 8);
//    assert(buf.readAbleSize() == 8);
//
//    std::cout << "重置功能测试通过!" << std::endl;
//}
//void test_stress() {
//    std::cout << "\n=== 压力测试 ===" << std::endl;
//
//    zxlog::Buffer buf;
//    const int ITERATIONS = 1000;
//    const int CHUNK_SIZE = 1024; // 1KB
//
//    std::vector<char> test_chunk(CHUNK_SIZE);
//    for (int i = 0; i < CHUNK_SIZE; ++i) {
//        test_chunk[i] = i % 256;
//    }
//
//    // 多次写入和读取
//    for (int i = 0; i < ITERATIONS; ++i) {
//        buf.push(test_chunk.data(), CHUNK_SIZE);
//        assert(buf.readAbleSize() == CHUNK_SIZE);
//
//        // 验证数据
//        const char* read_data = buf.begin();
//        for (int j = 0; j < CHUNK_SIZE; ++j) {
//            assert(read_data[j] == test_chunk[j]);
//        }
//
//        buf.pop(CHUNK_SIZE);
//        assert(buf.empty());
//    }
//
//    std::cout << "压力测试通过! 迭代次数: " << ITERATIONS << std::endl;
//}
//int main()
//{
//
    //单个缓冲区测试

    //test_buffer_swap();
    //test_basic_functionality();

    //test_boundary_conditions();

    //test_buffer_expansion();
    
    //test_pointer_movement();

    //test_reset_function();

    //test_stress();

    // 同步日志器类测试
    //  zxlog::LogSink::ptr stdout_sink = std::make_shared<zxlog::StdoutSink>();
    // zxlog::LogSink::ptr file_sink = std::make_shared<zxlog::FileSink>("tmp.log");
    // zxlog::LogSink::ptr roll_sink = std::make_shared<zxlog::RollSink>("test/tmp",1024*1024); // 1MB
    // std::vector<zxlog::LogSink::ptr> sinks;
    // sinks.push_back(stdout_sink);
    // // sinks.push_back(file_sink);
    // // sinks.push_back(roll_sink);
    // zxlog::Formatter formatter;
    // zxlog::SyncLogger sync_logger("SyncLogger",formatter,sinks);
    // sync_logger.debug(__FILE__,__LINE__,"%s","创建套接字失败...");

    // 落地方式类测试
    // zxlog::LogSink::ptr stdout_sink = std::make_shared<zxlog::StdoutSink>();
    // zxlog::LogSink::ptr file_sink = std::make_shared<zxlog::FileSink>("tmp.log");
    // zxlog::LogSink::ptr roll_sink = std::make_shared<zxlog::RollSink>("test/tmp",1024*1024); // 1MB
    // std::vector<zxlog::LogSink::ptr> sinks;
    // sinks.push_back(stdout_sink);
    // // sinks.push_back(file_sink);
    // // sinks.push_back(roll_sink);
    // zxlog::LogMsg msg("main.cc",__LINE__, "main", "创建套接字失败...", zxlog::LogLevel::Value::DEBUG);
    // zxlog::Formatter formatter;
    // std::string s = formatter.format(msg);
    // int count = 10;
    // while (count--)
    // {
    //     for (auto &e : sinks)
    //     {
    //         e->log(s.c_str(),s.size());
    //     }
    // }

    // util类创建目录测试
    //  zxlog::file::create_directory("a/b/c");

    // 日志格式化类设计
    // zxlog::Formatter formatter("asdaf%%d{%H:%M:%S}g%%g%T%t%T[%p]%T[%c]%T%f:%l%T%m%n");
    // zxlog::LogMsg msg(__LINE__, "main.cc", "创建套接字失败...", zxlog::LogLevel::Value::DEBUG);
    // formatter.format(std::cout, msg);
    // while(true)
    // {
    //     sleep(1);
    //     std::cout<<std::this_thread::get_id()<<std::endl;
    // }

    // 日志消息类设计
    //  zxlog::LogMessage msg(__LINE__,"main.cc","创建套接字失败...",zxlog::LogLevel::Value::DEBUG);

    // 日志等级类测试
    //  zxlog::LogLevel l;
    //  std::cout<<l.toString(zxlog::LogLevel::Value::DEBUG)<<std::endl;
    //  std::cout<<l.toString(zxlog::LogLevel::Value::ERROR)<<std::endl;
    //  std::cout<<l.toString(zxlog::LogLevel::Value::INFO)<<std::endl;
    //  std::cout<<zxlog::LogLevel::toString(zxlog::LogLevel::Value::INFO)<<std::endl;
//    return 0;
//}
